home *** CD-ROM | disk | FTP | other *** search
/ Aminet 43 / Aminet 43 (2001)(GTI - Schatztruhe)[!][Jun 2001].iso / Aminet / dev / moni / SystemViewer.lha / Source / SysAssigns.c < prev    next >
Encoding:
C/C++ Source or Header  |  1999-12-07  |  19.2 KB  |  804 lines
  1. /****h *SysAssigns [1.0] **********************************************
  2. **
  3. ** NAME
  4. **    SysAssigns
  5. **
  6. ** DESCRIPTION
  7. **    Display the logical assignments known to the OS.
  8. **
  9. **  GUI Designed by : Jim Steichen
  10. ***********************************************************************
  11. */
  12.  
  13. #include <string.h>
  14.  
  15. #include <exec/types.h>
  16. #include <exec/memory.h>
  17.  
  18. #include <AmigaDOSErrs.h>
  19.  
  20. #include <dos/dosextens.h>
  21.  
  22. #include <intuition/intuition.h>
  23. #include <intuition/classes.h>
  24. #include <intuition/classusr.h>
  25. #include <intuition/gadgetclass.h>
  26.  
  27. #include <libraries/gadtools.h>
  28.  
  29. #include <graphics/displayinfo.h>
  30. #include <graphics/gfxbase.h>
  31.  
  32. #include <clib/exec_protos.h>
  33. #include <clib/intuition_protos.h>
  34. #include <clib/gadtools_protos.h>
  35. #include <clib/graphics_protos.h>
  36. #include <clib/utility_protos.h>
  37. #include <clib/diskfont_protos.h>
  38. #include <clib/dos_protos.h>
  39.  
  40. #include "CPGM:GlobalObjects/CommonFuncs.h"
  41.  
  42. #include "SysLists.h"
  43.  
  44. #define ALV      0
  45. #define Update   1
  46. #define Cancel   2
  47. #define AddBt    3
  48. #define RemoveBt 4
  49.  
  50. #define Asgn_CNT 5
  51.  
  52. PRIVATE char ver[] = "$VER: SysAssigns 1.0 (12/20/1999) by J.T. Steichen";
  53.  
  54. typedef struct {
  55.  
  56.    LONG   Address;
  57.    STRPTR Name;
  58.    STRPTR Path;
  59.  
  60. } Assign;
  61.  
  62. PRIVATE Assign *Assignments = NULL;
  63.  
  64. PRIVATE char can[256] = { 0, }, *CurrentAssignName = &can[0];
  65.  
  66. PRIVATE struct TextFont     *AsgnFont  = NULL;
  67. PRIVATE struct Window       *AsgnWnd   = NULL;
  68. PRIVATE struct Gadget       *AsgnGList = NULL;
  69. PRIVATE struct IntuiMessage  AsgnMsg;
  70. PRIVATE struct Gadget       *AsgnGadgets[ Asgn_CNT ];
  71.  
  72. PRIVATE UWORD  AsgnLeft   = 0;
  73. PRIVATE UWORD  AsgnTop    = 16;
  74. PRIVATE UWORD  AsgnWidth  = 635;
  75. PRIVATE UWORD  AsgnHeight = 230;
  76. PRIVATE UBYTE *AsgnWdt    = (UBYTE *) "System Assigns Info:";
  77.  
  78. // -------------------------------------------------------------------
  79.  
  80. #define STRLENGTH 80
  81.  
  82. PRIVATE char ltitle[] = "Address  Assign               Path";
  83. PRIVATE char fmt[]    = "%08LX %-20.20s %-40.40s";
  84.  
  85. PRIVATE struct MinList ALVList  = { 0, };
  86.  
  87. PRIVATE struct Node    ALVNode  = { 0, };
  88. PRIVATE struct Node   *ALVNodes = NULL;
  89.  
  90. PRIVATE UBYTE         *NodeStrs = NULL;
  91.  
  92. // -------------------------------------------------------------------
  93.  
  94. PRIVATE UWORD AsgnGTypes[] = {
  95.  
  96.    LISTVIEW_KIND, BUTTON_KIND, BUTTON_KIND, 
  97.    BUTTON_KIND,   BUTTON_KIND
  98. };
  99.  
  100. PRIVATE int ALVClicked(      int whichitem );
  101. PRIVATE int UpdateClicked(   int dummy     );
  102. PRIVATE int CancelClicked(   int dummy     );
  103. PRIVATE int AddBtClicked(    int dummy     );
  104. PRIVATE int RemoveBtClicked( int dummy     );
  105.  
  106. PRIVATE struct NewGadget AsgnNGad[] = {
  107.  
  108.      2,   3, 627, 200,                NULL, NULL, ALV,    0, 
  109.    NULL, (APTR) ALVClicked,
  110.  
  111.      4, 205,  71,  17, (UBYTE *) "_Update", NULL, Update, PLACETEXT_IN, 
  112.    NULL, (APTR) UpdateClicked,
  113.  
  114.    554, 205,  72,  17, (UBYTE *) "_Cancel", NULL, Cancel, PLACETEXT_IN, 
  115.    NULL, (APTR) CancelClicked,
  116.  
  117.     80, 205,  71,  17, (UBYTE *) "_Add",    NULL, AddBt, PLACETEXT_IN, 
  118.    NULL, (APTR) AddBtClicked,
  119.  
  120.    160, 205,  71,  17, (UBYTE *) "Remove",  NULL, RemoveBt, PLACETEXT_IN, 
  121.    NULL, (APTR) RemoveBtClicked,
  122. };
  123.  
  124. PRIVATE ULONG AsgnGTags[] = {
  125.  
  126.    GTLV_ShowSelected, 0, LAYOUTA_Spacing, 2, TAG_DONE,
  127.  
  128.    GT_Underscore, '_', TAG_DONE,
  129.    GT_Underscore, '_', TAG_DONE,
  130.    GT_Underscore, '_', TAG_DONE,
  131.    GT_Underscore, '_', TAG_DONE
  132. };
  133.  
  134. // --------------------------------------------------------------------
  135.  
  136. PRIVATE int AssignmentCount = 0;
  137.  
  138. PRIVATE int CountAssignments( void )
  139. {
  140.    struct DosList *dl   = NULL;
  141.    int             rval = 0;
  142.  
  143.    dl = LockDosList( LDF_ASSIGNS | LDF_READ );
  144.  
  145.    while ((dl = NextDosEntry( dl, LDF_ASSIGNS )) != NULL)
  146.       rval++;
  147.  
  148.    UnLockDosList( LDF_ASSIGNS | LDF_READ );
  149.  
  150.    return( rval );
  151. }
  152.  
  153. PRIVATE STRPTR MakeSTRPTR( BSTR s )
  154. {
  155.    STRPTR ris;
  156.    STRPTR eq;
  157.     
  158.    if (s == NULL)
  159.       return( NULL );
  160.  
  161.    eq = (STRPTR) BADDR( s );
  162.  
  163.    if (eq[0] == NULL)
  164.       return( NULL );
  165.  
  166.    ris = (STRPTR) malloc( eq[0] + 2 );
  167.  
  168.    memcpy( ris, eq + 1, eq[0] );
  169.  
  170.    ris[ eq[0] ] = 0;
  171.  
  172.    strcat( ris, ":" ); // Add a Colon to indicate Logical Assignment.
  173.  
  174.    return( ris );
  175. }
  176.  
  177. PRIVATE char strtmp[256] = "";
  178.  
  179. PRIVATE int GetAssignmentList( void )
  180. {
  181.    struct DosList *dl = NULL;
  182.    int             i;
  183.    
  184.    AssignmentCount = CountAssignments();
  185.    
  186.    Assignments = (Assign *) malloc( AssignmentCount * sizeof( Assign ) );
  187.  
  188.    if (Assignments == NULL)
  189.       {
  190.       return( -1 );
  191.       }
  192.       
  193.    dl = LockDosList( LDF_ASSIGNS | LDF_READ );
  194.    i  = 0;
  195.  
  196.    while ((dl = NextDosEntry( dl, LDF_ASSIGNS )) != NULL)
  197.       {
  198.       NameFromLock( dl->dol_Lock, strtmp, 255 );
  199.  
  200.       Assignments[i].Address = dl;
  201.       Assignments[i].Name    = MakeSTRPTR( dl->dol_Name );
  202.       Assignments[i].Path    = strdup( strtmp );
  203.  
  204.       i++;
  205.       }
  206.  
  207.    UnLockDosList( LDF_ASSIGNS | LDF_READ );
  208.    return( 0 );
  209. }
  210.  
  211. PRIVATE void FreeDosList( void )
  212. {
  213.    int i;
  214.  
  215.    for (i = 0; i < AssignmentCount; i++)
  216.       {
  217.       free( Assignments[i].Name ); // malloc in MakeSTRPTR().
  218.       free( Assignments[i].Path ); // alloc'd by strdup() function.
  219.       }
  220.  
  221.    free( Assignments );
  222.  
  223.    Assignments     = NULL;
  224.    AssignmentCount = 0;
  225.  
  226.    return;
  227. }
  228.  
  229. PRIVATE int MakeAssignList( void )
  230. {
  231.    int i = 1; // Skip the titles in NodeStrs[0].
  232.  
  233.    for (i = 1; i <= AssignmentCount; i++)
  234.       {
  235.       sprintf( &NodeStrs[ i * STRLENGTH ], fmt,
  236.  
  237.                Assignments[ i - 1 ].Address,
  238.                Assignments[ i - 1 ].Name,
  239.                Assignments[ i - 1 ].Path
  240.              );
  241.       }
  242.  
  243.    return( 0 );
  244. }
  245.  
  246. PRIVATE void CloseAsgnWindow( void )
  247. {
  248.    if (AsgnWnd != NULL)
  249.       {
  250.       CloseWindow( AsgnWnd );
  251.       AsgnWnd = NULL;
  252.       }
  253.  
  254.    if (AsgnGList != NULL)
  255.       {
  256.       FreeGadgets( AsgnGList );
  257.       AsgnGList = NULL;
  258.       }
  259.  
  260.    if (AsgnFont != NULL)
  261.       {
  262.       CloseFont( AsgnFont );
  263.       AsgnFont = NULL;
  264.       }
  265.  
  266.    return;
  267. }
  268.  
  269. PRIVATE int AsgnCloseWindow( void )
  270. {
  271.    CloseAsgnWindow();
  272.    return( (int) FALSE );
  273. }
  274.  
  275. PRIVATE int CancelClicked( int dummy )
  276. {
  277.    return( AsgnCloseWindow() );
  278. }
  279.  
  280. PRIVATE int ALVClicked( int whichitem )
  281. {
  282.    if (whichitem == 0)
  283.       {
  284.       strcpy( CurrentAssignName, "" );
  285.  
  286.       SetWindowTitles( AsgnWnd, AsgnWdt, (UBYTE *) 0xFFFFFFFF );
  287.       return( (int) TRUE );
  288.       }
  289.    else
  290.       {
  291.       char t[32], *tmp = &t[0];
  292.       
  293.       strncpy( tmp, 
  294.                (char const *) Assignments[ whichitem - 1 ].Name, 
  295.                31
  296.              );
  297.  
  298.       strcpy( CurrentAssignName, 
  299.               (char const *) Assignments[ whichitem - 1 ].Name
  300.             );
  301.       
  302.       SetWindowTitles( AsgnWnd, tmp, (UBYTE *) 0xFFFFFFFF );
  303.       }
  304.  
  305.    return( (int) TRUE );
  306. }
  307.  
  308. PRIVATE int UpdateClicked( int dummy )
  309. {
  310.    int i;
  311.  
  312.    SetWindowTitles( AsgnWnd, AsgnWdt, (UBYTE *) 0xFFFFFFFF );
  313.  
  314.    HideListFromView( AsgnGadgets[ ALV ], AsgnWnd );   
  315.  
  316.    // See if the list of assignments has grown bigger:
  317.  
  318.    if ((i = CountAssignments()) > AssignmentCount)
  319.       {
  320.       // Deallocate old data in memory, we need a bigger list:
  321.       FreeDosList();
  322.       FreeMem( NodeStrs, STRLENGTH * (AssignmentCount + 1) );
  323.       FreeMem( ALVNodes, (AssignmentCount + 1) * sizeof( struct Node ) );
  324.       NodeStrs = NULL;
  325.       ALVNodes = NULL;
  326.  
  327.       // Allocate a new area in memory for the data:
  328.  
  329.       if (GetAssignmentList() < 0)  // Recalculate AssignmentCount also.
  330.          {
  331.          SetReqButtons( "Aaarrrggghhh!!" );
  332.  
  333.          sprintf( ErrMsg, "Out of memory space, Aborting!!" );
  334.  
  335.          (void) Handle_Problem( ErrMsg, "System Problem:", NULL );
  336.  
  337.          return( FALSE );
  338.          }
  339.  
  340.       if ((ALVNodes = (struct Node *) 
  341.                        AllocMem( sizeof( struct Node ) 
  342.                                          * (AssignmentCount + 1),
  343.                                  MEMF_CLEAR 
  344.                                )
  345.          ) == NULL)
  346.          {
  347.          int ans = 0;
  348.  
  349.          sprintf( ErrMsg, "Out of memory space, Abort?" );
  350.          ans = Handle_Problem( ErrMsg, "System Problem:", NULL );
  351.  
  352.          if (ans == 0)
  353.             return( TRUE );
  354.          else
  355.             return( FALSE );
  356.          }
  357.  
  358.       if ((NodeStrs = (char *) 
  359.                        AllocMem( STRLENGTH * (AssignmentCount + 1),
  360.                                  MEMF_CLEAR 
  361.                                )
  362.          ) == NULL)
  363.          {
  364.          int ans = 0;
  365.  
  366.          FreeMem( ALVNodes, (AssignmentCount + 1) * sizeof( struct Node));
  367.  
  368.          sprintf( ErrMsg, "Out of memory space, Abort?" );
  369.          ans = Handle_Problem( ErrMsg, "System Problem:", NULL );
  370.  
  371.          if (ans == 0)
  372.             return( TRUE );
  373.          else
  374.             return( FALSE );
  375.          }
  376.  
  377.       // Copy the title into the top node of the list view:
  378.       strcpy( &NodeStrs[0], ltitle );
  379.  
  380.       CopyMem( (char *) &ALVNode, (char *) ALVNodes, 
  381.                (long) sizeof( struct Node )
  382.              );
  383.  
  384.       for (i = 1; i <= AssignmentCount; i++)
  385.          {
  386.          ALVNodes[i].ln_Name = &NodeStrs[ i * STRLENGTH ];
  387.          ALVNodes[i].ln_Pri  = AssignmentCount - i;
  388.          }
  389.  
  390.       NewList( (struct List *) &ALVList ); // might not be needed.
  391.  
  392.       for (i = 0; i < AssignmentCount; i++)
  393.          Enqueue( (struct List *) &ALVList, &ALVNodes[ i ] );
  394.       } 
  395.  
  396.    for (i = 1; i <= AssignmentCount; i++)
  397.        NodeStrs[ i * STRLENGTH ] = '\0'; // Kill old ListView strings.
  398.  
  399.    // Make the list:
  400.    (void) MakeAssignList();
  401.  
  402.    ModifyListView( AsgnGadgets[ ALV ], AsgnWnd, &ALVList, NULL );
  403.  
  404.    GT_RefreshWindow( AsgnWnd, NULL );
  405.    return( (int) TRUE );
  406. }
  407.  
  408. PRIVATE int AddBtClicked( int dummy )
  409. {
  410.    IMPORT char *assignname;
  411.    IMPORT char *pathname;
  412.  
  413.    int rval = AddAssignment();
  414.       
  415.    if (rval < 0)
  416.       {
  417.       sprintf( ErrMsg, "Couldn't open an Add Assignment Requester!" );
  418.       
  419.       SetReqButtons( "OKAY" );
  420.       (void) Handle_Problem( ErrMsg, "Program Problem:", NULL );
  421.       SetReqButtons( "CONTINUE|ABORT!" );
  422.       }
  423.    else if (rval == FALSE)
  424.       {
  425.       return( (int) TRUE ); // User pressed the CANCEL button.
  426.       }
  427.    else if (rval > 1)
  428.       {
  429.       char cmd[256] = "";
  430.  
  431.       if (strlen( assignname ) < 1)
  432.          {
  433.          SetReqButtons( "Aaarrgghh!!" );
  434.  
  435.          Handle_Problem( "You didn't supply a name for the assignemnt!",
  436.                          "User ERROR:", NULL
  437.                        );
  438.  
  439.          SetReqButtons( "CONTINUE|ABORT!" );
  440.          return( (int) TRUE );
  441.          }      
  442.  
  443.       if (strlen( pathname ) < 1)
  444.          {
  445.          SetReqButtons( "Aaarrgghh!!" );
  446.  
  447.          Handle_Problem( "You didn't supply a pathname for the assignemnt!",
  448.                          "User ERROR:", NULL
  449.                        );
  450.  
  451.          SetReqButtons( "CONTINUE|ABORT!" );
  452.          return( (int) TRUE );
  453.          }      
  454.  
  455.       if (strstr( assignname, ":" ) == NULL)
  456.          strcat( assignname, ":" ); // User didn't supply the colon!
  457.          
  458.       sprintf( &cmd[0], "Assign %s %s", assignname, pathname );      
  459.  
  460.       if (System( &cmd[0], TAG_DONE ) < 0)
  461.          {
  462.          sprintf( ErrMsg,
  463.                   "'%s'\ncouldn't be run by the System,"
  464.                   "\ncheck your spelling!",
  465.                   cmd
  466.                 );
  467.  
  468.          (void) Handle_Problem( ErrMsg, "Invalid Command Path?", NULL );
  469.          return( (int) TRUE );
  470.          }
  471.  
  472.       Delay( 30 );
  473.       (void) UpdateClicked( 0 );
  474.       }      
  475.  
  476.    return( (int) TRUE );
  477. }
  478.  
  479. PRIVATE int RemoveBtClicked( int dummy )
  480. {
  481.    char cmd[256] = "";
  482.    int  ans = 0;
  483.    
  484.    if (strlen( CurrentAssignName ) < 1)
  485.       {
  486.       SetReqButtons( "Aaarrgghh!!" );
  487.  
  488.       Handle_Problem( "Click on an Assignment in the List View first!",
  489.                       "User ERROR:", NULL
  490.                     );
  491.  
  492.       SetReqButtons( "CONTINUE|ABORT!" );
  493.       return( (int) TRUE );
  494.       }
  495.  
  496.    // -------------------------------------------------------
  497.    SetReqButtons( "I'm SURE!|No Way!" );
  498.  
  499.    sprintf( ErrMsg, "Are you sure you want to remove %s?", 
  500.             CurrentAssignName
  501.           );
  502.    
  503.    ans = Handle_Problem( ErrMsg, "Sanity Check:", NULL ); 
  504.  
  505.    SetReqButtons( "CONTINUE|ABORT!" );
  506.  
  507.    if (ans != 0)
  508.       return( (int) TRUE );
  509.    // -------------------------------------------------------
  510.       
  511.    sprintf( &cmd[0], "Assign %s REMOVE", CurrentAssignName );
  512.  
  513.    if (System( &cmd[0], TAG_DONE ) < 0)
  514.       {
  515.       sprintf( ErrMsg,
  516.                "'%s'\ncouldn't be run by the System,"
  517.                "\ncheck your spelling!",
  518.                cmd
  519.              );
  520.  
  521.       (void) Handle_Problem( ErrMsg, "Invalid Command Path?", NULL );
  522.       return( (int) TRUE );
  523.       }
  524.  
  525.    Delay( 30 );
  526.    (void) UpdateClicked( 0 );
  527.  
  528.    return( (int) TRUE );
  529. }
  530.  
  531.  
  532. PRIVATE int AsgnVanillaKey( int whichkey )
  533. {
  534.    int rval = TRUE;
  535.    
  536.    switch (whichkey)
  537.       {
  538.       case 'a':
  539.       case 'A':
  540.          rval = AddBtClicked( 0 );
  541.          break;
  542.  
  543.       case 'u':
  544.       case 'U':
  545.          rval = UpdateClicked( 0 );
  546.          break;
  547.       
  548.       case 'c':
  549.       case 'C':
  550.       case 'q':
  551.       case 'Q':
  552.       case 'x':
  553.       case 'X':
  554.          rval = CancelClicked( 0 );
  555.       
  556.       default:
  557.          break;
  558.       }
  559.        
  560.    return( rval );
  561. }
  562.  
  563. PRIVATE int HandleAsgnIDCMP( void )
  564. {
  565.    struct IntuiMessage *m = NULL;
  566.    int                (*func)( int code );
  567.    BOOL                 running = TRUE;
  568.  
  569.    while (running == TRUE)
  570.       {
  571.       if ((m = GT_GetIMsg( AsgnWnd->UserPort )) == NULL)
  572.          {
  573.          (void) Wait( 1L << AsgnWnd->UserPort->mp_SigBit );
  574.          continue;
  575.          }
  576.  
  577.       CopyMem( (char *) m, (char *) &AsgnMsg, 
  578.                (long) sizeof( struct IntuiMessage )
  579.              );
  580.  
  581.       GT_ReplyIMsg( m );
  582.  
  583.       switch ( AsgnMsg.Class )
  584.          {
  585.          case IDCMP_REFRESHWINDOW:
  586.             GT_BeginRefresh( AsgnWnd );
  587.             GT_EndRefresh( AsgnWnd, TRUE );
  588.             break;
  589.  
  590.          case IDCMP_CLOSEWINDOW:
  591.             running = AsgnCloseWindow();
  592.             break;
  593.  
  594.          case IDCMP_VANILLAKEY:
  595.             running = AsgnVanillaKey( (int) AsgnMsg.Code );
  596.             break;
  597.  
  598.          case IDCMP_GADGETUP:
  599.          case IDCMP_GADGETDOWN:
  600.             func = (void *)((struct Gadget *) AsgnMsg.IAddress)->UserData;
  601.  
  602.             if (func != NULL)
  603.                running = func( (int) AsgnMsg.Code );
  604.    
  605.             break;
  606.          }
  607.       }
  608.  
  609.    return( running );
  610. }
  611.  
  612. PRIVATE int OpenAsgnWindow( void )
  613. {
  614.    struct NewGadget  ng;
  615.    struct Gadget    *g;
  616.    UWORD             lc, tc;
  617.    UWORD             wleft = AsgnLeft, wtop = AsgnTop, ww, wh;
  618.  
  619.    ComputeFont( Scr, Font, &CFont, AsgnWidth, AsgnHeight );
  620.  
  621.    ww = ComputeX( CFont.FontX, AsgnWidth );
  622.    wh = ComputeY( CFont.FontY, AsgnHeight );
  623.  
  624.    if ((wleft + ww + CFont.OffX + Scr->WBorRight) > Scr->Width)
  625.       wleft = Scr->Width - ww;
  626.  
  627.    if ((wtop + wh + CFont.OffY + Scr->WBorBottom) > Scr->Height)
  628.       wtop = Scr->Height - wh;
  629.  
  630.    if ((AsgnFont = OpenDiskFont( Font )) == NULL)
  631.       return( -5 );
  632.  
  633.    if ((g = CreateContext( &AsgnGList )) == NULL)
  634.       return( -1 );
  635.  
  636.    for (lc = 0, tc = 0; lc < Asgn_CNT; lc++)
  637.       {
  638.       CopyMem( (char *) &AsgnNGad[lc], (char *) &ng, 
  639.                (long) sizeof( struct NewGadget )
  640.              );
  641.  
  642.       ng.ng_VisualInfo = VisualInfo;
  643.       ng.ng_TextAttr   = Font;
  644.  
  645.       ng.ng_LeftEdge   = CFont.OffX + ComputeX( CFont.FontX, 
  646.                                                 ng.ng_LeftEdge
  647.                                               );
  648.  
  649.       ng.ng_TopEdge    = CFont.OffY + ComputeY( CFont.FontY, 
  650.                                                 ng.ng_TopEdge
  651.                                               );
  652.  
  653.       ng.ng_Width      = ComputeX( CFont.FontX, ng.ng_Width );
  654.       ng.ng_Height     = ComputeY( CFont.FontY, ng.ng_Height );
  655.  
  656.       AsgnGadgets[lc] = g = CreateGadgetA( (ULONG) AsgnGTypes[lc], 
  657.                               g, 
  658.                               &ng, 
  659.                               (struct TagItem *) &AsgnGTags[tc] );
  660.  
  661.       while (AsgnGTags[tc] != NULL)
  662.          tc += 2;
  663.  
  664.       tc++;
  665.  
  666.       if (g == NULL)
  667.          return( -2 );
  668.       }
  669.  
  670.    if ((AsgnWnd = OpenWindowTags( NULL,
  671.  
  672.                     WA_Left,        wleft,
  673.                     WA_Top,         wtop,
  674.                     WA_Width,       ww + CFont.OffX + Scr->WBorRight,
  675.                     WA_Height,      wh + CFont.OffY + Scr->WBorBottom,
  676.  
  677.                     WA_IDCMP,       LISTVIEWIDCMP | BUTTONIDCMP 
  678.                       | IDCMP_CLOSEWINDOW | IDCMP_REFRESHWINDOW 
  679.                       | IDCMP_VANILLAKEY,
  680.  
  681.                     WA_Flags,       WFLG_DRAGBAR | WFLG_DEPTHGADGET 
  682.                       | WFLG_CLOSEGADGET | WFLG_SMART_REFRESH 
  683.                       | WFLG_ACTIVATE | WFLG_RMBTRAP,
  684.  
  685.                     WA_Gadgets,     AsgnGList,
  686.                     WA_Title,       AsgnWdt,
  687.                     WA_ScreenTitle, ScrTitle,
  688.                     TAG_DONE )
  689.       ) == NULL)
  690.       return( -4 );
  691.  
  692.    GT_RefreshWindow( AsgnWnd, NULL );
  693.  
  694.    return( 0 );
  695. }
  696.  
  697. PUBLIC int main( void )
  698. {
  699.    int i = 0;
  700.  
  701.    if (SetupSystemList( &OpenAsgnWindow ) < 0)
  702.       {
  703.       fprintf( stderr, "Couldn't open a System ListViewer!\n" );
  704.       return( RETURN_FAIL );
  705.       }
  706.    
  707.    SetNotifyWindow( AsgnWnd );
  708.  
  709.    AssignmentCount = CountAssignments();
  710.  
  711.    ALVNode.ln_Succ = (struct Node *) ALVList.mlh_Tail;
  712.    ALVNode.ln_Pred = (struct Node *) ALVList.mlh_Head;
  713.    ALVNode.ln_Type = 0;
  714.    ALVNode.ln_Pri  = AssignmentCount;
  715.    ALVNode.ln_Name = ltitle;
  716.  
  717.    if ((ALVNodes = (struct Node *) 
  718.                     AllocMem( sizeof( struct Node ) 
  719.                                       * (AssignmentCount + 1),
  720.                               MEMF_CLEAR 
  721.                             )
  722.       ) == NULL)
  723.       {
  724.       sprintf( ErrMsg, "Out of memory space, Abort?" );
  725.       
  726.       SetReqButtons( "Aaargrggghhhh!" );
  727.       (void) Handle_Problem( ErrMsg, "System Problem:", NULL );
  728.  
  729.       ShutdownSystemList();
  730.       return( ERROR_NO_FREE_STORE );
  731.       }
  732.  
  733.    if ((NodeStrs = (char *) 
  734.                     AllocMem( STRLENGTH * (AssignmentCount + 1),
  735.                               MEMF_CLEAR 
  736.                             )
  737.       ) == NULL)
  738.       {
  739.       FreeMem( ALVNodes, (AssignmentCount + 1) * sizeof( struct Node ) );
  740.  
  741.       sprintf( ErrMsg, "Out of memory space, Abort?" );
  742.  
  743.       SetReqButtons( "Aaargrggghhhh!" );
  744.       (void) Handle_Problem( ErrMsg, "System Problem:", NULL );
  745.  
  746.       ShutdownSystemList();
  747.       return( ERROR_NO_FREE_STORE );
  748.       }
  749.  
  750.    strcpy( &NodeStrs[0], ltitle );
  751.  
  752.    CopyMem( (char *) &ALVNode, (char *) ALVNodes, 
  753.             (long) sizeof( struct Node )
  754.           );
  755.  
  756.    for (i = 1; i <= AssignmentCount; i++)
  757.       {
  758.       ALVNodes[i].ln_Name = &NodeStrs[ i * STRLENGTH ];
  759.       ALVNodes[i].ln_Pri  = AssignmentCount - i;
  760.       }
  761.  
  762.    NewList( (struct List *) &ALVList );      
  763.  
  764.    for (i = 0; i < AssignmentCount; i++)
  765.       Enqueue( (struct List *) &ALVList, &ALVNodes[ i ] );
  766.  
  767.    if (GetAssignmentList() < 0)
  768.       {
  769.       sprintf( ErrMsg, "Out of memory space, Abort?" );
  770.  
  771.       FreeMem( NodeStrs, (AssignmentCount + 1) * STRLENGTH );
  772.       FreeMem( ALVNodes, (AssignmentCount + 1) * sizeof( struct Node ) );
  773.  
  774.       SetReqButtons( "Aaargrggghhhh!" );
  775.       (void) Handle_Problem( ErrMsg, "System Problem:", NULL );
  776.  
  777.       ShutdownSystemList();
  778.       return( ERROR_NO_FREE_STORE );
  779.       }
  780.       
  781.    // Make the list:
  782.    (void) MakeAssignList();   
  783.  
  784.    ModifyListView( AsgnGadgets[ ALV ], AsgnWnd, 
  785.                    (struct List *) &ALVList, NULL
  786.                  );
  787.  
  788.    GT_RefreshWindow( AsgnWnd, NULL );
  789.  
  790.    (void) HandleAsgnIDCMP();
  791.    
  792.    ShutdownSystemList();
  793.  
  794.    FreeMem( NodeStrs, (AssignmentCount + 1) * STRLENGTH );
  795.    FreeMem( ALVNodes, (AssignmentCount + 1) * sizeof( struct Node ) );
  796.  
  797.    if (Assignments != NULL)
  798.       FreeDosList();
  799.       
  800.    return( RETURN_OK );
  801. }
  802.  
  803. /* --------------------- END of SysAssigns.c file! -------------- */
  804.